package com.berchen.test;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class SpinLock {

    private final AtomicReference<Thread> atomicReference = new AtomicReference<>();

    // 自旋锁 加锁
    public void lock() {
        do {
            // 自旋中
        } while (!atomicReference.compareAndSet(null, Thread.currentThread()));
    }

    // 自旋锁 解锁
    public void unlock() {
        do {
            // 自旋中
        } while (!atomicReference.compareAndSet(Thread.currentThread(), null));
    }

    private int num=0;  // 线程共享资源

    /**
     * 不加锁的时候 多个线程 同时进入方法进行操作  但是 有睡眠  num++ 了  但是 线程丢失了执行权 另外一个线程来执行 同样丢失
     * 最后线程醒来 抢夺CPU执行权 然后就输出 最后输出结果就有问题
     * 加锁了就不会有这个问题
     * @throws InterruptedException
     */
    public void test() throws InterruptedException {
        lock(); // 加锁
        num++;
        Thread.sleep(1000); // 睡眠 让当前线程 丢失执行权
        System.out.println(Thread.currentThread().getName()+"--------"+num);
        unlock();   // 解锁
    }
    public static void main(String[] args) {

        SpinLock spinLock = new SpinLock();
        for (int i = 0; i < 10; i++) {
            int num=i;
            new Thread(()->{
                try {
                    spinLock.test();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },num+"--------").start();
        }

    }
}

